home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / filesyst / ext2 / ext2ed-0.000 / ext2ed-0 / ext2ed-0.1 / general_com.c < prev    next >
C/C++ Source or Header  |  1995-08-24  |  19KB  |  749 lines
  1. /*
  2.  
  3. /usr/src/ext2ed/general_com.c
  4.  
  5. A part of the extended file system 2 disk editor.
  6.  
  7. ---------------------
  8. General user commands
  9. ---------------------
  10.  
  11. First written on: April 9 1995
  12.  
  13. Copyright (C) 1995 Gadi Oxman
  14.  
  15. */
  16.  
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <string.h>
  20.  
  21. #include "ext2ed.h"
  22.  
  23. void help (char *command_line)
  24.  
  25. {
  26.     int i,max_line=0;
  27.     char argument [80],*ptr;
  28.  
  29.     werase (show_pad);wmove (show_pad,0,0);
  30.  
  31.     ptr=parse_word (command_line,argument);
  32.  
  33.     if (*ptr!=0) {
  34.          ptr=parse_word (ptr,argument);
  35.          if (*argument!=0) {         
  36.              detailed_help (argument);
  37.              return;
  38.         }
  39.     }
  40.  
  41.     if (current_type!=NULL) {
  42.         
  43.         wprintw (show_pad,"Type %s specific commands:\n",current_type->name);max_line++;
  44.         
  45.         if (current_type->type_commands.last_command==-1) {
  46.             wprintw (show_pad,"\nnone\n");max_line+=2;
  47.         }
  48.         else
  49.             for (i=0;i<=current_type->type_commands.last_command;i++) {
  50.                 if (i%5==0) {
  51.                     wprintw (show_pad,"\n");max_line++;
  52.                 }
  53.                 wprintw (show_pad,"%-13s",current_type->type_commands.names [i]);
  54.                 if (i%5!=4)
  55.                     wprintw (show_pad,";  ");                
  56.             }
  57.         
  58.         wprintw (show_pad,"\n\n");max_line+=2;
  59.     }        
  60.  
  61.     if (ext2_commands.last_command != -1) {
  62.         wprintw (show_pad,"ext2 filesystem general commands: \n");max_line++;
  63.         for (i=0;i<=ext2_commands.last_command;i++) {
  64.             if (i%5==0) {
  65.                 wprintw (show_pad,"\n");max_line++;
  66.             }
  67.             wprintw (show_pad,"%-13s",ext2_commands.names [i]);
  68.             if (i%5!=4)
  69.                 wprintw (show_pad,";  ");                
  70.  
  71.         }
  72.         wprintw (show_pad,"\n\n");max_line+=2;
  73.     }
  74.  
  75.     wprintw (show_pad,"General commands: \n");
  76.     
  77.     for (i=0;i<=general_commands.last_command;i++) {
  78.         if (i%5==0) {
  79.             wprintw (show_pad,"\n");max_line++;
  80.         }
  81.         wprintw (show_pad,"%-13s",general_commands.names [i]);
  82.         if (i%5!=4)
  83.             wprintw (show_pad,";  ");                
  84.     }
  85.     
  86.     wprintw (show_pad,"\n\n");max_line+=2;
  87.     
  88.     wprintw (show_pad,"EXT2ED ver %d.%d (%s)\n",version_major,version_minor,revision_date);
  89.     wprintw (show_pad,"Copyright (C) 1995 Gadi Oxman\n");
  90.     wprintw (show_pad,"EXT2ED is hereby placed under the terms of the GNU General Public License.\n\n");
  91.     wprintw (show_pad,"EXT2ED was programmed as a student project in the software laboratory\n");
  92.     wprintw (show_pad,"of the faculty of electrical engineering in the\n");
  93.     wprintw (show_pad,"Technion - Israel Institute of Technology\n");
  94.     wprintw (show_pad,"with the guide of Avner Lottem and Dr. Ilana David.\n");
  95.  
  96.     max_line+=6;
  97.     
  98.     wprintw (show_pad,"\n\n");max_line+=2;
  99.     
  100.     wprintw (show_pad,"Please feel free to mail me at (currently) %s\n",email_address);
  101.     wprintw (show_pad,"with any commet, suggestion, and of-course, bug report concerning EXT2ED.\n");
  102.     
  103.     max_line+=2;
  104.     
  105.     show_pad_info.line=0;show_pad_info.max_line=max_line;
  106.  
  107.     werase (show_win);wmove (show_win,0,0);
  108.     wprintw (show_win,"EXT2ED help");
  109.     
  110.     refresh_show_win ();
  111.     refresh_show_pad ();
  112. }
  113.  
  114. void detailed_help (char *text)
  115.  
  116. {
  117.     int i;
  118.     
  119.     if (current_type != NULL)
  120.         for (i=0;i<=current_type->type_commands.last_command;i++) {
  121.             if (strcmp (current_type->type_commands.names [i],text)==0) {
  122.                 wprintw (show_pad,"%s - %s\n",text,current_type->type_commands.descriptions [i]);
  123.                 refresh_show_pad ();return;
  124.             }
  125.         }
  126.  
  127.     for (i=0;i<=ext2_commands.last_command;i++) {
  128.         if (strcmp (ext2_commands.names [i],text)==0) {
  129.                 wprintw (show_pad,"%s - %s\n",text,ext2_commands.descriptions [i]);
  130.                 refresh_show_pad ();return;
  131.         }
  132.     }
  133.  
  134.     for (i=0;i<=general_commands.last_command;i++) {
  135.         if (strcmp (general_commands.names [i],text)==0) {
  136.                 wprintw (show_pad,"%s - %s\n",text,general_commands.descriptions [i]);
  137.                 refresh_show_pad ();return;
  138.         }
  139.     }
  140.  
  141.     if (strcmp ("quit",text)==0) {
  142.         wprintw (show_pad,"quit - Exists EXT2ED");
  143.         refresh_show_pad ();return;
  144.     }
  145.  
  146.     wprintw (show_pad,"Error - Command %s not aviable now\n",text);
  147.     refresh_show_pad ();return;
  148. }
  149.  
  150.  
  151.  
  152. void set_device (char *command_line)
  153.  
  154. {
  155.     char *ptr,new_device [80];
  156.     
  157.     ptr=parse_word (command_line,new_device);
  158.     if (*ptr==0) {
  159.         wprintw (command_win,"Error - Device name not specified\n");
  160.         refresh_command_win ();return;
  161.     }
  162.     parse_word (ptr,new_device);    
  163.     check_mounted (new_device);
  164.     if (mounted && !AllowMountedRead) {
  165.         wprintw (command_win,"Error - Filesystem is mounted, aborting\n");
  166.         wprintw (command_win,"You may wish to use the AllowMountedRead on configuration option\n");
  167.         refresh_command_win ();return;
  168.     }
  169.     
  170.     if (mounted && AllowMountedRead) {
  171.         wprintw (command_win,"Warning - Filesystem is mounted. Displayed data may be unreliable.\n");
  172.         refresh_command_win ();
  173.     }
  174.  
  175.     if (device_handle!=NULL)
  176.         fclose (device_handle);
  177.         
  178.     if ( (device_handle=fopen (new_device,"rb"))==NULL) {
  179.         wprintw (command_win,"Error - Can not open device %s\n",new_device);refresh_command_win ();
  180.         return;
  181.     }
  182.     else {
  183.         strcpy (device_name,new_device);
  184.         write_access=0;                /* Write access disabled */
  185.         current_type=NULL;            /* There is no type now */
  186.         remember_lifo.entries_count=0;        /* Empty Object memory */
  187.         free_user_commands (&ext2_commands);    /* Free filesystem specific objects */
  188.         free_struct_descriptors ();
  189.         if (!set_file_system_info ()) {        /* Error while getting info --> abort */
  190.             free_user_commands (&ext2_commands);
  191.             free_struct_descriptors ();
  192.             fclose (device_handle);
  193.             device_handle=NULL;        /* Notice that our device is still not set up */
  194.             device_offset=-1;
  195.             return;
  196.         }
  197.         if (*AlternateDescriptors)        /* Check if user defined objects exist */
  198.             set_struct_descriptors (AlternateDescriptors);
  199.         dispatch ("setoffset 0");
  200.         dispatch ("help");            /* Show help screen */
  201.         wprintw (command_win,"Device changed to %s",device_name);refresh_command_win ();
  202.     }
  203. }
  204.  
  205. void set_offset (char *command_line)
  206.  
  207. {
  208.     long mult=1;
  209.     long new_offset;
  210.     char *ptr,new_offset_buffer [80];
  211.     
  212.     if (device_handle==NULL) {
  213.         wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
  214.         return;
  215.     }
  216.     
  217.     ptr=parse_word (command_line,new_offset_buffer);
  218.     
  219.     if (*ptr==0) {
  220.         wprintw (command_win,"Error - No argument specified\n");refresh_command_win ();
  221.         return;
  222.     }
  223.  
  224.     ptr=parse_word (ptr,new_offset_buffer);
  225.  
  226.     if (strcmp (new_offset_buffer,"block")==0) {
  227.         mult=file_system_info.block_size;
  228.         ptr=parse_word (ptr,new_offset_buffer);
  229.     }
  230.  
  231.     if (strcmp (new_offset_buffer,"type")==0) {
  232.         if (current_type==NULL) {
  233.             wprintw (command_win,"Error - No type set\n");refresh_command_win ();
  234.             return;
  235.         }
  236.  
  237.         mult=current_type->length;
  238.         ptr=parse_word (ptr,new_offset_buffer);
  239.     }
  240.  
  241.     if (*new_offset_buffer==0) {
  242.         wprintw (command_win,"Error - No offset specified\n");refresh_command_win ();
  243.         return;
  244.     }
  245.  
  246.     if (new_offset_buffer [0]=='+') {
  247.         if (device_offset==-1) {
  248.             wprintw (command_win,"Error - Select a fixed offset first\n");refresh_command_win ();
  249.             return;
  250.         }
  251.         new_offset=device_offset+atol (new_offset_buffer+1)*mult;
  252.     }
  253.     
  254.     else if (new_offset_buffer [0]=='-') {
  255.         if (device_offset==-1) {
  256.             wprintw (command_win,"Error - Select a fixed offset first\n");refresh_command_win ();
  257.             return;
  258.         }
  259.         new_offset=device_offset-atol (new_offset_buffer+1)*mult;
  260.         if (new_offset<0) new_offset=0;
  261.     }
  262.     
  263.     else 
  264.         new_offset=atol (new_offset_buffer)*mult;
  265.     
  266.     if ( (fseek (device_handle,new_offset,SEEK_SET))==-1) {
  267.         wprintw (command_win,"Error - Failed to seek to offset %ld in device %s\n",new_offset,device_name);
  268.         refresh_command_win ();
  269.         return;
  270.     };
  271.     device_offset=new_offset;
  272.     wprintw (command_win,"Device offset changed to %ld\n",device_offset);refresh_command_win ();
  273.     load_type_data ();
  274.     type_data.offset_in_block=0;
  275. }
  276.  
  277. void set (char *command_line)
  278.  
  279. {
  280.     unsigned short *int_ptr;
  281.     unsigned char *char_ptr;
  282.     unsigned long *long_ptr,offset=0;
  283.     int i,found=0;
  284.     char *ptr,buffer [80],variable [80],value [80];
  285.     
  286.     if (device_handle==NULL) {
  287.         wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
  288.         return;
  289.     }
  290.  
  291.     if (current_type==NULL) {
  292.         hex_set (command_line);
  293.         return;
  294.     }
  295.  
  296.     ptr=parse_word (command_line,buffer);
  297.     if (ptr==NULL || *ptr==0) {
  298.         wprintw (command_win,"Error - Missing arguments\n");refresh_command_win ();
  299.         return;
  300.     }
  301.     parse_word (ptr,buffer);
  302.     ptr=strchr (buffer,'=');
  303.     if (ptr==NULL) {
  304.         wprintw (command_win,"Error - Bad syntax\n");refresh_command_win ();return;
  305.     }
  306.     strncpy (variable,buffer,ptr-buffer);variable [ptr-buffer]=0;
  307.     strcpy (value,++ptr);
  308.  
  309.     if (current_type==NULL) {
  310.         wprintw (command_win,"Sorry, not yet supported\n");refresh_command_win ();return;
  311.     }
  312.     
  313.     for (i=0;i<current_type->fields_num && !found;i++) {
  314.         if (strcmp (current_type->field_names [i],variable)==0) {
  315.             found=1;
  316.             ptr=type_data.u.buffer+offset;
  317.             switch (current_type->field_lengths [i]) {
  318.                 case 1:
  319.                     char_ptr=(unsigned char *) ptr;
  320.                     *char_ptr=(char) atoi (value);
  321.                     wprintw (command_win,"Variable %s set to %u\n",variable,*char_ptr);refresh_command_win ();
  322.                     break;
  323.                 case 2:
  324.                     int_ptr=(unsigned short *) ptr;
  325.                     *int_ptr=atoi (value);
  326.                     wprintw (command_win,"Variable %s set to %u\n",variable,*int_ptr);refresh_command_win ();
  327.                     break;
  328.  
  329.                 case 4:
  330.                     long_ptr=(unsigned long *) ptr;
  331.                     *long_ptr=atol (value);
  332.                     wprintw (command_win,"Variable %s set to %lu\n",variable,*long_ptr);refresh_command_win ();
  333.                     break;
  334.             }
  335.         }
  336.         offset+=current_type->field_lengths [i];
  337.     }
  338.     if (found)
  339.         dispatch ("show");
  340.     else {
  341.         wprintw (command_win,"Error - Variable %s not found\n",variable);
  342.         refresh_command_win ();
  343.     }
  344. }
  345.  
  346. void hex_set (char *command_line)
  347.  
  348. {
  349.     unsigned char tmp;
  350.     char *ptr,buffer [80],*ch_ptr;
  351.     int mode=HEX;
  352.     
  353.     ptr=parse_word (command_line,buffer);
  354.     if (*ptr==0) {
  355.         wprintw (command_win,"Error - Argument not specified\n");refresh_command_win ();return;
  356.     }
  357.  
  358.     ptr=parse_word (ptr,buffer);
  359.  
  360.     if (strcasecmp (buffer,"text")==0) {
  361.         mode=TEXT;
  362.         strcpy (buffer,ptr);
  363.     }
  364.  
  365.     else if (strcasecmp (buffer,"hex")==0) {
  366.         mode=HEX;
  367.         ptr=parse_word (ptr,buffer);
  368.     }
  369.  
  370.     if (*buffer==0) {
  371.         wprintw (command_win,"Error - Data not specified\n");refresh_command_win ();return;
  372.     }
  373.  
  374.     if (mode==HEX) {
  375.         do {
  376.             tmp=(unsigned char) strtol (buffer,NULL,16);
  377.             type_data.u.buffer [type_data.offset_in_block]=tmp;
  378.             type_data.offset_in_block++;
  379.             ptr=parse_word (ptr,buffer);
  380.             if (type_data.offset_in_block==file_system_info.block_size) {
  381.                 if (*ptr) {
  382.                     wprintw (command_win,"Error - Ending offset outside block, only partial string changed\n");
  383.                     refresh_command_win ();
  384.                 }
  385.                 type_data.offset_in_block--;
  386.             }
  387.         } while (*buffer) ;
  388.     }
  389.  
  390.     else {
  391.         ch_ptr=buffer;
  392.         while (*ch_ptr) {
  393.             tmp=(unsigned char) *ch_ptr++;
  394.             type_data.u.buffer [type_data.offset_in_block]=tmp;
  395.             type_data.offset_in_block++;
  396.             if (type_data.offset_in_block==file_system_info.block_size) {
  397.                 if (*ch_ptr) {
  398.                     wprintw (command_win,"Error - Ending offset outside block, only partial string changed\n");
  399.                     refresh_command_win ();
  400.                 }
  401.                 type_data.offset_in_block--;
  402.             }
  403.         }
  404.     }
  405.     
  406.     strcpy (buffer,"show");dispatch (buffer);
  407. }
  408.  
  409.  
  410.  
  411. void set_type (char *command_line)
  412.  
  413. {
  414.     struct struct_descriptor *descriptor_ptr;
  415.     char *ptr,buffer [80],tmp_buffer [80];
  416.     short found=0;
  417.  
  418.     if (!load_type_data ())
  419.         return;
  420.  
  421.     ptr=parse_word (command_line,buffer);
  422.     parse_word (ptr,buffer);
  423.     
  424.     if (strcmp (buffer,"none")==0 || strcmp (buffer,"hex")==0) {
  425.         wprintw (command_win,"Data will be shown as hex dump\n");refresh_command_win ();
  426.         current_type=NULL;
  427.         sprintf (tmp_buffer,"show");dispatch (tmp_buffer);
  428.         return;
  429.     }
  430.     
  431.     descriptor_ptr=first_type;
  432.     while (descriptor_ptr!=NULL && !found) {
  433.         if (strcmp (descriptor_ptr->name,buffer)==0)
  434.             found=1;
  435.         else
  436.             descriptor_ptr=descriptor_ptr->next;
  437.     }
  438.     if (found) {
  439.         wprintw (command_win,"Structure type set to %s\n",buffer);refresh_command_win ();
  440.         current_type=descriptor_ptr;
  441.         sprintf (tmp_buffer,"show");dispatch (tmp_buffer);
  442.     }
  443.     else {
  444.         wprintw (command_win,"Error - %s is not a valid type\n",buffer);refresh_command_win ();
  445.     }
  446. }    
  447.  
  448.  
  449. void show (char *command_line)
  450.  
  451. {
  452.     unsigned int i,l,temp_int;
  453.     unsigned long offset=0,temp_long;    
  454.     unsigned char temp_char,*ch_ptr;
  455.     void *ptr;
  456.  
  457.     if (device_handle==NULL)
  458.         return;
  459.  
  460.     show_pad_info.line=0;
  461.     
  462.     if (current_type==NULL) {
  463.         wmove (show_pad,0,0);
  464.         ch_ptr=type_data.u.buffer;
  465.         for (l=0;l<file_system_info.block_size/16;l++) {
  466.             wprintw (show_pad,"%08ld :  ",offset);
  467.             for (i=0;i<16;i++) {
  468.                 if (type_data.offset_in_block==offset+i)
  469.                     wattrset (show_pad,A_REVERSE);
  470.             
  471.                 if (ch_ptr [i]>=' ' && ch_ptr [i]<='z')
  472.                     wprintw (show_pad,"%c",ch_ptr [i]);
  473.                 else
  474.                     wprintw (show_pad,".");
  475.                 if (type_data.offset_in_block==offset+i)
  476.                     wattrset (show_pad,A_NORMAL);
  477.             }
  478.             wprintw (show_pad,"   ");
  479.             for (i=0;i<16;i++) {
  480.                 if (type_data.offset_in_block==offset+i)
  481.                     wattrset (show_pad,A_REVERSE);
  482.             
  483.                 wprintw (show_pad,"%02x",ch_ptr [i]);
  484.  
  485.                 if (type_data.offset_in_block==offset+i) {
  486.                     wattrset (show_pad,A_NORMAL);
  487.                     show_pad_info.line=l-l % show_pad_info.display_lines;
  488.                 }
  489.  
  490.                 wprintw (show_pad," ");
  491.             }
  492.             wprintw (show_pad,"\n");
  493.             offset+=16;
  494.             ch_ptr+=16;
  495.         }
  496.         show_pad_info.max_line=l-1;show_pad_info.max_col=COLS-1;
  497.         refresh_show_pad ();show_info ();
  498.     }
  499.     else {
  500.         wmove (show_pad,0,0);l=0;
  501.         for (i=0;i<current_type->fields_num;i++) {
  502.             wprintw (show_pad,"%-20s = ",current_type->field_names [i]);
  503.             ptr=type_data.u.buffer+offset;
  504.             switch (current_type->field_lengths [i]) {
  505.                 case 1:
  506.                     temp_char=*((unsigned char *) ptr);
  507.                     wprintw (show_pad,"%3u (0x%02x",temp_char,temp_char);
  508.                     if (temp_char>=' ' && temp_char<='z')
  509.                         wprintw (show_pad," , %c)\n",temp_char);
  510.                     else
  511.                         wprintw (show_pad,")\n");
  512.  
  513.                     offset ++;l++;
  514.                     break;
  515.                 case 2:
  516.                     temp_int=*((unsigned short *) ptr);
  517.                     wprintw (show_pad,"%u (0x%x)\n",temp_int,temp_int);
  518.                     offset +=2;l++;
  519.                     break;
  520.                 case 4:
  521.                     temp_long=*((unsigned long *) ptr);
  522.                     wprintw (show_pad,"%lu\n",temp_long);
  523.                     offset +=4;l++;
  524.                     break;
  525.             }
  526. /*            offset+=current_type->field_lengths [i]; */
  527.         }
  528.         current_type->length=offset;
  529.         show_pad_info.max_line=l-1;
  530.         refresh_show_pad ();show_info ();
  531.     }
  532. }
  533.  
  534. void next (char *command_line)
  535.  
  536. {
  537.     long offset=1;
  538.     char *ptr,buffer [80];
  539.  
  540.     ptr=parse_word (command_line,buffer);
  541.     
  542.     if (*ptr!=0) {
  543.         ptr=parse_word (ptr,buffer);
  544.         offset*=atol (buffer);
  545.     }
  546.     
  547.     if (current_type!=NULL) {
  548.         sprintf (buffer,"setoffset type +%ld",offset);
  549.         dispatch (buffer);
  550.         return;
  551.     }
  552.  
  553.     if (type_data.offset_in_block+offset < file_system_info.block_size) {
  554.         type_data.offset_in_block+=offset;
  555.         sprintf (buffer,"show");dispatch (buffer);
  556.     }
  557.         
  558.     else {
  559.         wprintw (command_win,"Error - Offset out of block\n");refresh_command_win ();
  560.     }
  561. }
  562.  
  563. void prev (char *command_line)
  564.  
  565. {
  566.     long offset=1;
  567.     char *ptr,buffer [80];
  568.  
  569.     ptr=parse_word (command_line,buffer);
  570.     
  571.     if (*ptr!=0) {
  572.         ptr=parse_word (ptr,buffer);
  573.         offset*=atol (buffer);
  574.     }
  575.     
  576.     if (current_type!=NULL) {
  577.         sprintf (buffer,"setoffset type -%ld",offset);
  578.         dispatch (buffer);
  579.         return;
  580.     }
  581.  
  582.     if (type_data.offset_in_block-offset >= 0) {
  583.         type_data.offset_in_block-=offset;
  584.         sprintf (buffer,"show");dispatch (buffer);
  585.     }
  586.     
  587.     else {
  588.         wprintw (command_win,"Error - Offset out of block\n");refresh_command_win ();
  589.     }
  590. }
  591.  
  592. void pgdn (char *commnad_line) 
  593.  
  594. {
  595.     show_pad_info.line+=show_pad_info.display_lines;
  596.     refresh_show_pad ();refresh_show_win ();
  597. }
  598.  
  599. void pgup (char *command_line)
  600.  
  601. {
  602.     show_pad_info.line-=show_pad_info.display_lines;
  603.     refresh_show_pad ();refresh_show_win ();
  604. }
  605.  
  606. void redraw (char *command_line)
  607.  
  608. {
  609.     redraw_all ();
  610.     dispatch ("show");
  611. }
  612.  
  613. void remember (char *command_line)
  614.  
  615. {
  616.     long entry_num;
  617.     char *ptr,buffer [80];
  618.     
  619.     if (device_handle==NULL) {
  620.         wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
  621.         return;
  622.     }
  623.  
  624.     ptr=parse_word (command_line,buffer);
  625.     
  626.     if (*ptr==0) {
  627.         wprintw (command_win,"Error - Argument not specified\n");refresh_command_win ();
  628.         return;        
  629.     }
  630.     
  631.     ptr=parse_word (ptr,buffer);
  632.  
  633.     entry_num=remember_lifo.entries_count++;
  634.     if (entry_num>REMEMBER_COUNT-1) {
  635.         entry_num=0;
  636.         remember_lifo.entries_count--;
  637.     }
  638.     
  639.     remember_lifo.offset [entry_num]=device_offset;
  640.     remember_lifo.type [entry_num]=current_type;
  641.     strcpy (remember_lifo.name [entry_num],buffer);
  642.     
  643.     if (current_type!=NULL)
  644.         wprintw (command_win,"Object %s in Offset %ld remembered as %s\n",current_type->name,device_offset,buffer);
  645.     else
  646.         wprintw (command_win,"Offset %ld remembered as %s\n",device_offset,buffer);
  647.             
  648.     refresh_command_win ();
  649. }
  650.  
  651. void recall (char *command_line)
  652.  
  653. {
  654.     char *ptr,buffer [80];
  655.     long entry_num;
  656.  
  657.     if (device_handle==NULL) {
  658.         wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
  659.         return;
  660.     }
  661.  
  662.     ptr=parse_word (command_line,buffer);
  663.  
  664.     if (*ptr==0) {
  665.         wprintw (command_win,"Error - Argument not specified\n");refresh_command_win ();
  666.         return;        
  667.     }
  668.  
  669.     ptr=parse_word (ptr,buffer);
  670.  
  671.     
  672.     for (entry_num=remember_lifo.entries_count-1;entry_num>=0;entry_num--) {
  673.         if (strcmp (remember_lifo.name [entry_num],buffer)==0)
  674.             break;    
  675.     }
  676.     
  677.     if (entry_num==-1) {
  678.         wprintw (command_win,"Error - Can not recall %s\n",buffer);refresh_command_win ();
  679.         return;
  680.     }
  681.  
  682.     sprintf (buffer,"setoffset %ld",remember_lifo.offset [entry_num]);dispatch (buffer);
  683.     if (remember_lifo.type [entry_num] != NULL) {
  684.         sprintf (buffer,"settype %s",remember_lifo.type [entry_num]->name);dispatch (buffer);    
  685.     }
  686.  
  687.     else {
  688.         sprintf (buffer,"settype none");dispatch (buffer);    
  689.     }
  690.             
  691.     wprintw (command_win,"Object %s in Offset %ld recalled\n",current_type->name,device_offset);
  692.     refresh_command_win ();
  693. }
  694.  
  695. void enable_write (char *command_line)
  696.  
  697. {
  698.     FILE *fp;
  699.  
  700.     if (device_handle==NULL) {
  701.         wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
  702.         return;
  703.     }
  704.  
  705.     if (!AllowChanges) {
  706.         wprintw (command_win,"Sorry, write access is not allowed\n");
  707.             return;
  708.         }
  709.         
  710.         if (mounted) {
  711.             wprintw (command_win,"Error - Filesystem is mounted\n");
  712.         return;            
  713.         }
  714.         
  715.     if ( (fp=fopen (device_name,"r+b"))==NULL) {
  716.         wprintw (command_win,"Error - Can not open device %s for reading and writing\n",device_name);refresh_command_win ();
  717.         return;
  718.     }
  719.     fclose (device_handle);
  720.     device_handle=fp;write_access=1;
  721.     wprintw (command_win,"Write access enabled - Be careful\n");refresh_command_win ();
  722. }
  723.  
  724. void disable_write (char *command_line)
  725.  
  726. {
  727.     FILE *fp;
  728.  
  729.     if (device_handle==NULL) {
  730.         wprintw (command_win,"Error - No device opened\n");refresh_command_win ();
  731.         return;
  732.     }
  733.  
  734.     if ( (fp=fopen (device_name,"rb"))==NULL) {
  735.         wprintw (command_win,"Error - Can not open device %s\n",device_name);refresh_command_win ();
  736.         return;
  737.     }
  738.     
  739.     fclose (device_handle);
  740.     device_handle=fp;write_access=0;
  741.     wprintw (command_win,"Write access disabled\n");refresh_command_win ();
  742. }
  743.  
  744. void write_data (char *command_line)
  745.  
  746. {
  747.     write_type_data ();
  748. }
  749.